home *** CD-ROM | disk | FTP | other *** search
/ Aminet 51 / Aminet 51 (2002)(GTI - Schatztruhe)[!][Oct 2002].iso / Aminet / gfx / fract / FlashMandelWOS.lha / FlashMandel / Developer / Modules / React / FM_ConfirmReq_React.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-08-02  |  14.0 KB  |  701 lines
  1. /*
  2.  *  FM_ConfirmReq_React.c
  3.  *
  4.  *  Requester for:
  5.  *     print-request,
  6.  *     exit-request,
  7.  *     render-request,
  8.  *     overwrite-request,
  9.  *     newscr-request with reaction-support
  10.  *
  11.  *  $VER: V2.0, 13.10.2001
  12.  *  Coded by Edgar Schwan
  13.  */
  14.  
  15. #include <intuition/gadgetclass.h>
  16. #include <intuition/classusr.h>
  17. #include <intuition/screens.h>
  18. #include <classes/window.h>
  19. #include <dos/dos.h>
  20.  
  21. #include <clib/intuition_protos.h>
  22. #include <clib/exec_protos.h>
  23. #include <clib/graphics_protos.h>
  24. #include <clib/alib_protos.h>
  25.  
  26. #include <pragmas/intuition_pragmas.h>
  27. #include <pragmas/exec_pragmas.h>
  28. #include <pragmas/graphics_pragmas.h>
  29.  
  30. #include <stdlib.h>
  31. #include <stdio.h>
  32.  
  33. #include "FM_ConfirmReq_React.h"
  34. #include "FM_ReactionBasics.h"
  35. #include "FM_Reaction.h"
  36. #include "FM_ReactionCD.h"
  37.  
  38. extern ULONG *PALETTE;
  39.  
  40. struct ReactWinData *print_rwd = NULL;
  41. struct ReactWinData *exit_rwd = NULL;
  42. struct ReactWinData *newscr_rwd = NULL;
  43. struct ReactWinData *render_rwd = NULL;
  44. struct ReactWinData *overwr_rwd = NULL;
  45.  
  46. /*    Do_PrintRequest(): print-requester (full handling).
  47.  
  48.         SYNOPSIS: BOOL res = Do_PrintRequest
  49.                         (
  50.                         struct Window      *Win;
  51.                         char                  *PubScreenName;
  52.                         WORD                     Left;
  53.                         WORD                    Top;
  54.                         );
  55.  
  56.         INPUTS:        Win:
  57.                             Pointer to the parent-window.
  58.  
  59.                         PubScreenName:
  60.                             name of the public-screen, where the window should appear.
  61.  
  62.                         Left:
  63.                             Left edge of print-window (not supported yet).
  64.  
  65.                         Top:
  66.                             Top edge of print-window (not supported yet).
  67.  
  68.         RETURNS:        res:
  69.                             Is TRUE, if user confirms to print.
  70. */
  71.  
  72. BOOL Do_PrintRequest(struct Window *Win, char *PubScreenName, WORD Left, WORD Top)
  73. {
  74. BOOL rc = FALSE;
  75. LONG result = RESULT_NOTHING;
  76. ULONG waitsigs, mask;
  77.  
  78. if (OpenPrintReqWindow(PubScreenName) == TRUE) {
  79.     waitsigs = print_rwd->RWD_WSignals|SIGBREAKF_CTRL_C;
  80.  
  81.     while(result == RESULT_NOTHING) {
  82.         mask = Wait(waitsigs);
  83.         if (mask & print_rwd->RWD_WSignals) {
  84.             result = HandlePrintReqWindow();
  85.             }
  86.         if (mask & SIGBREAKF_CTRL_C) {
  87.             result = RESULT_CANCEL;
  88.             }
  89.         if (result == RESULT_OK) rc = TRUE;
  90.         }
  91.  
  92.     ClosePrintReqWindow();
  93.     } else DisplayError(Win, TXT_ERR_Window, 5L);
  94.  
  95. LoadRGB32(ViewPortAddress (Win), (APTR) PALETTE);
  96. return(rc);
  97. }
  98.  
  99. /*    OpenPrintReqWindow(): open window of print-requester.
  100.  
  101.         SYNOPSIS: BOOL res = OpenPrintReqWindow
  102.                         (
  103.                         char      *PubScreenName;
  104.                         );
  105.  
  106.         INPUTS:        PubScreenName:
  107.                             name of the public-screen, where the window should appear.
  108.  
  109.         RETURNS:        res:
  110.                             TRUE, if successfull.
  111. */
  112.  
  113. BOOL OpenPrintReqWindow(char *PubScreenName)
  114. {
  115. if (print_rwd = OpenReactionWindow(WIN_PRT_ID, GROUP_Prt_ID, PubScreenName)) return(TRUE);
  116. return(FALSE);
  117. }
  118.  
  119. /*    ClosePrintReqWindow(): close window of print-requester.
  120.  
  121.         SYNOPSIS: void = ClosePrintReqWindow
  122.                         (
  123.                         void
  124.                         );
  125.  
  126.         INPUTS:        -
  127.  
  128.         RETURNS:        -
  129. */
  130.  
  131. void ClosePrintReqWindow(void)
  132. {
  133. CloseReactionWindow(print_rwd);
  134. }
  135.  
  136. /*    HandlePrintReqWindow(): Handle the messages of the print-requester.
  137.  
  138.         SYNOPSIS: LONG res = HandlePrintReqWindow
  139.                         (
  140.                         void;
  141.                         );
  142.  
  143.         INPUTS:        -
  144.  
  145.         RETURNS:        res:
  146.                             result of messages:    RESULT_NOTHING -> nothing happens.
  147.                                                         RESULT_CANCEL  -> user canceled.
  148.                                                         RESULT_OK      -> user wants to print.
  149. */
  150.  
  151. LONG HandlePrintReqWindow(void)
  152. {
  153. LONG rc = RESULT_NOTHING;
  154. ULONG result, code;
  155.  
  156. while((result = DoMethod(print_rwd->RWD_WindowObject, WM_HANDLEINPUT, &code)) != WMHI_LASTMSG) {
  157.  
  158.     switch (result & WMHI_CLASSMASK) {
  159.         case WMHI_CLOSEWINDOW:
  160.             rc = RESULT_CANCEL;
  161.             break;
  162.  
  163.         case WMHI_GADGETUP:
  164.             switch (result & RL_GADGETMASK) {
  165.                 case Prt_BUTTON_Yes:
  166.                     rc = RESULT_OK;
  167.                     break;
  168.                 case Prt_BUTTON_No:
  169.                     rc = RESULT_CANCEL;
  170.                     break;
  171.                 }
  172.             break;
  173.         }
  174.     }
  175. return(rc);
  176. }
  177.  
  178. /*    Do_ExitRequest(): exit-requester (full handling).
  179.  
  180.         SYNOPSIS: BOOL res = Do_ExitRequest
  181.                         (
  182.                         struct Window      *Win;
  183.                         char                  *PubScreenName;
  184.                         WORD                     Left;
  185.                         WORD                    Top;
  186.                         );
  187.  
  188.         INPUTS:        Win:
  189.                             Pointer to the parent-window.
  190.  
  191.                         PubScreenName:
  192.                             name of the public-screen, where the window should appear.
  193.  
  194.                         Left:
  195.                             Left edge of exit-window (not supported yet).
  196.  
  197.                         Top:
  198.                             Top edge of exit-window (not supported yet).
  199.  
  200.         RETURNS:        res:
  201.                             Is TRUE, if user confirms to exit.
  202. */
  203.  
  204. BOOL Do_ExitRequest(struct Window *Win, char *PubScreenName, WORD Left, WORD Top)
  205. {
  206. BOOL rc = FALSE;
  207. LONG result = RESULT_NOTHING;
  208. ULONG waitsigs, mask;
  209.  
  210. if (OpenExitReqWindow(PubScreenName) == TRUE) {
  211.     waitsigs = exit_rwd->RWD_WSignals|SIGBREAKF_CTRL_C;
  212.  
  213.     while(result == RESULT_NOTHING) {
  214.         mask = Wait(waitsigs);
  215.         if (mask & exit_rwd->RWD_WSignals) {
  216.             result = HandleExitReqWindow();
  217.             }
  218.         if (mask & SIGBREAKF_CTRL_C) {
  219.             result = RESULT_CANCEL;
  220.             }
  221.         if (result == RESULT_OK) rc = TRUE;
  222.         }
  223.  
  224.     CloseExitReqWindow();
  225.     } else DisplayError(Win, TXT_ERR_Window, 5L);
  226.  
  227. LoadRGB32(ViewPortAddress (Win), (APTR) PALETTE);
  228. return(rc);
  229. }
  230.  
  231. /*    OpenExitReqWindow(): open window of exit-requester.
  232.  
  233.         SYNOPSIS: BOOL res = OpenExitReqWindow
  234.                         (
  235.                         char                  *PubScreenName;
  236.                         );
  237.  
  238.         INPUTS:        -
  239.  
  240.         RETURNS:        res:
  241.                             TRUE, if successfull.
  242. */
  243.  
  244. BOOL OpenExitReqWindow(char *PubScreenName)
  245. {
  246. if (exit_rwd = OpenReactionWindow(WIN_EXIT_ID, GROUP_Exit_ID, PubScreenName)) return(TRUE);
  247. return(FALSE);
  248. }
  249.  
  250. /*    CloseExitReqWindow(): close window of exit-requester.
  251.  
  252.         SYNOPSIS: void = CloseExitReqWindow
  253.                         (
  254.                         void
  255.                         );
  256.  
  257.         INPUTS:        -
  258.  
  259.         RETURNS:        -
  260. */
  261.  
  262. void CloseExitReqWindow(void)
  263. {
  264. CloseReactionWindow(exit_rwd);
  265. }
  266.  
  267. /*    HandleExitReqWindow(): Handle the messages of the exit-requester.
  268.  
  269.         SYNOPSIS: LONG res = HandleExitReqWindow
  270.                         (
  271.                         void;
  272.                         );
  273.  
  274.         INPUTS:        -
  275.  
  276.         RETURNS:        res:
  277.                             result of messages:    RESULT_NOTHING -> nothing happens.
  278.                                                         RESULT_CANCEL  -> user canceled.
  279.                                                         RESULT_OK      -> user wants to exit.
  280. */
  281.  
  282. LONG HandleExitReqWindow(void)
  283. {
  284. LONG rc = RESULT_NOTHING;
  285. ULONG result, code;
  286.  
  287. while((result = DoMethod(exit_rwd->RWD_WindowObject, WM_HANDLEINPUT, &code)) != WMHI_LASTMSG) {
  288.  
  289.     switch (result & WMHI_CLASSMASK) {
  290.         case WMHI_CLOSEWINDOW:
  291.             rc = RESULT_CANCEL;
  292.             break;
  293.  
  294.         case WMHI_GADGETUP:
  295.             switch (result & RL_GADGETMASK) {
  296.                 case Exit_BUTTON_Yes:
  297.                     rc = RESULT_OK;
  298.                     break;
  299.                 case Exit_BUTTON_No:
  300.                     rc = RESULT_CANCEL;
  301.                     break;
  302.                 }
  303.             break;
  304.         }
  305.     }
  306. return(rc);
  307. }
  308.  
  309. /*    Do_NewScrRequest(): newscr-requester (full handling).
  310.  
  311.         SYNOPSIS: BOOL res = Do_NewScrRequest
  312.                         (
  313.                         struct Window      *Win;
  314.                         char                  *PubScreenName;
  315.                         WORD                     Left;
  316.                         WORD                    Top;
  317.                         );
  318.  
  319.         INPUTS:        Win:
  320.                             Pointer to the parent-window.
  321.  
  322.                         PubScreenName:
  323.                             name of the public-screen, where the window should appear.
  324.  
  325.                         Left:
  326.                             Left edge of newscr-window (not supported yet).
  327.  
  328.                         Top:
  329.                             Top edge of newscr-window (not supported yet).
  330.  
  331.         RETURNS:        res:
  332.                             Is TRUE, if user confirms to update rendering.
  333. */
  334.  
  335. BOOL Do_NewScrRequest(struct Window *Win, char *PubScreenName, WORD Left, WORD Top)
  336. {
  337. BOOL rc = FALSE;
  338. LONG result = RESULT_NOTHING;
  339. ULONG waitsigs, mask;
  340.  
  341. if (OpenNewScrReqWindow(PubScreenName) == TRUE) {
  342.     waitsigs = newscr_rwd->RWD_WSignals|SIGBREAKF_CTRL_C;
  343.  
  344.     while(result == RESULT_NOTHING) {
  345.         mask = Wait(waitsigs);
  346.         if (mask & newscr_rwd->RWD_WSignals) {
  347.             result = HandleNewScrReqWindow();
  348.             }
  349.         if (mask & SIGBREAKF_CTRL_C) {
  350.             result = RESULT_CANCEL;
  351.             }
  352.         if (result == RESULT_OK) rc = TRUE;
  353.         }
  354.  
  355.     CloseNewScrReqWindow();
  356.     }
  357.  
  358. LoadRGB32(ViewPortAddress (Win), (APTR) PALETTE);
  359. return(rc);
  360. }
  361.  
  362. /*    OpenNewScrReqWindow(): open window of newscr-requester.
  363.  
  364.         SYNOPSIS: BOOL res = OpenNewScrReqWindow
  365.                         (
  366.                         char                  *PubScreenName;
  367.                         );
  368.  
  369.         INPUTS:        -
  370.  
  371.         RETURNS:        res:
  372.                             TRUE, if successfull.
  373. */
  374.  
  375. BOOL OpenNewScrReqWindow(char *PubScreenName)
  376. {
  377. if (newscr_rwd = OpenReactionWindow(WIN_NEWSCR_ID, GROUP_NewScr_ID, PubScreenName)) return(TRUE);
  378. return(FALSE);
  379. }
  380.  
  381. /*    CloseNewScrReqWindow(): close window of newscr-requester.
  382.  
  383.         SYNOPSIS: void = CloseNewScrReqWindow
  384.                         (
  385.                         void
  386.                         );
  387.  
  388.         INPUTS:        -
  389.  
  390.         RETURNS:        -
  391. */
  392.  
  393. void CloseNewScrReqWindow(void)
  394. {
  395. CloseReactionWindow(newscr_rwd);
  396. }
  397.  
  398. /*    HandleNewScrReqWindow(): Handle the messages of the newscr-requester.
  399.  
  400.         SYNOPSIS: LONG res = HandleNewScrReqWindow
  401.                         (
  402.                         void;
  403.                         );
  404.  
  405.         INPUTS:        -
  406.  
  407.         RETURNS:        res:
  408.                             result of messages:    RESULT_NOTHING -> nothing happens.
  409.                                                         RESULT_CANCEL  -> user canceled.
  410.                                                         RESULT_OK      -> user wants to render.
  411. */
  412.  
  413. LONG HandleNewScrReqWindow(void)
  414. {
  415. LONG rc = RESULT_NOTHING;
  416. ULONG result, code;
  417.  
  418. while((result = DoMethod(newscr_rwd->RWD_WindowObject, WM_HANDLEINPUT, &code)) != WMHI_LASTMSG) {
  419.  
  420.     switch (result & WMHI_CLASSMASK) {
  421.         case WMHI_CLOSEWINDOW:
  422.             rc = RESULT_CANCEL;
  423.             break;
  424.  
  425.         case WMHI_GADGETUP:
  426.             switch (result & RL_GADGETMASK) {
  427.                 case NewScr_BUTTON_Yes:
  428.                     rc = RESULT_OK;
  429.                     break;
  430.                 case NewScr_BUTTON_No:
  431.                     rc = RESULT_CANCEL;
  432.                     break;
  433.                 }
  434.             break;
  435.         }
  436.     }
  437. return(rc);
  438. }
  439.  
  440. /*    Do_RenderRequest(): render-requester (full handling).
  441.  
  442.         SYNOPSIS: BOOL res = Do_RenderRequest
  443.                         (
  444.                         struct Window      *Win;
  445.                         char                  *PubScreenName;
  446.                         WORD                     Left;
  447.                         WORD                    Top;
  448.                         );
  449.  
  450.         INPUTS:        Win:
  451.                             Pointer to the parent-window.
  452.  
  453.                         PubScreenName:
  454.                             name of the public-screen, where the window should appear.
  455.  
  456.                         Left:
  457.                             Left edge of render-window (not supported yet).
  458.  
  459.                         Top:
  460.                             Top edge of render-window (not supported yet).
  461.  
  462.         RETURNS:        res:
  463.                             Is TRUE, if user confirms to update rendering.
  464. */
  465.  
  466. BOOL Do_RenderRequest(struct Window *Win, char *PubScreenName, WORD Left, WORD Top)
  467. {
  468. BOOL rc = FALSE;
  469. LONG result = RESULT_NOTHING;
  470. ULONG waitsigs, mask;
  471.  
  472. if (OpenRenderReqWindow(PubScreenName) == TRUE) {
  473.     waitsigs = render_rwd->RWD_WSignals|SIGBREAKF_CTRL_C;
  474.  
  475.     while(result == RESULT_NOTHING) {
  476.         mask = Wait(waitsigs);
  477.         if (mask & render_rwd->RWD_WSignals) {
  478.             result = HandleRenderReqWindow();
  479.             }
  480.         if (mask & SIGBREAKF_CTRL_C) {
  481.             result = RESULT_CANCEL;
  482.             }
  483.         if (result == RESULT_OK) rc = TRUE;
  484.         }
  485.  
  486.     CloseRenderReqWindow();
  487.     } else DisplayError(Win, TXT_ERR_Window, 5L);
  488.  
  489. LoadRGB32(ViewPortAddress (Win), (APTR) PALETTE);
  490. return(rc);
  491. }
  492.  
  493. /*    OpenRenderReqWindow(): open window of render-requester.
  494.  
  495.         SYNOPSIS: BOOL res = OpenRenderReqWindow
  496.                         (
  497.                         char                  *PubScreenName;
  498.                         );
  499.  
  500.         INPUTS:        -
  501.  
  502.         RETURNS:        res:
  503.                             TRUE, if successfull.
  504. */
  505.  
  506. BOOL OpenRenderReqWindow(char *PubScreenName)
  507. {
  508. if (render_rwd = OpenReactionWindow(WIN_RENDER_ID, GROUP_Render_ID, PubScreenName)) return(TRUE);
  509. return(FALSE);
  510. }
  511.  
  512. /*    CloseRenderReqWindow(): close window of render-requester.
  513.  
  514.         SYNOPSIS: void = CloseRenderReqWindow
  515.                         (
  516.                         void
  517.                         );
  518.  
  519.         INPUTS:        -
  520.  
  521.         RETURNS:        -
  522. */
  523.  
  524. void CloseRenderReqWindow(void)
  525. {
  526. CloseReactionWindow(render_rwd);
  527. }
  528.  
  529. /*    HandleRenderReqWindow(): Handle the messages of the render-requester.
  530.  
  531.         SYNOPSIS: LONG res = HandleRenderReqWindow
  532.                         (
  533.                         void;
  534.                         );
  535.  
  536.         INPUTS:        -
  537.  
  538.         RETURNS:        res:
  539.                             result of messages:    RESULT_NOTHING -> nothing happens.
  540.                                                         RESULT_CANCEL  -> user canceled.
  541.                                                         RESULT_OK      -> user wants to render.
  542. */
  543.  
  544. LONG HandleRenderReqWindow(void)
  545. {
  546. LONG rc = RESULT_NOTHING;
  547. ULONG result, code;
  548.  
  549. while((result = DoMethod(render_rwd->RWD_WindowObject, WM_HANDLEINPUT, &code)) != WMHI_LASTMSG) {
  550.  
  551.     switch (result & WMHI_CLASSMASK) {
  552.         case WMHI_CLOSEWINDOW:
  553.             rc = RESULT_CANCEL;
  554.             break;
  555.  
  556.         case WMHI_GADGETUP:
  557.             switch (result & RL_GADGETMASK) {
  558.                 case Rend_BUTTON_Yes:
  559.                     rc = RESULT_OK;
  560.                     break;
  561.                 case Rend_BUTTON_No:
  562.                     rc = RESULT_CANCEL;
  563.                     break;
  564.                 }
  565.             break;
  566.         }
  567.     }
  568. return(rc);
  569. }
  570.  
  571. /*    Do_OverwriteRequest(): overwrite-requester (full handling).
  572.  
  573.         SYNOPSIS: BOOL res = Do_OverwriteRequest
  574.                         (
  575.                         struct Window      *Win;
  576.                         char                  *PubScreenName;
  577.                         WORD                     Left;
  578.                         WORD                    Top;
  579.                         );
  580.  
  581.         INPUTS:        Win:
  582.                             Pointer to the parent-window.
  583.  
  584.                         PubScreenName:
  585.                             name of the public-screen, where the window should appear.
  586.  
  587.                         Left:
  588.                             Left edge of overwr-window (not supported yet).
  589.  
  590.                         Top:
  591.                             Top edge of overwr-window (not supported yet).
  592.  
  593.         RETURNS:        res:
  594.                             Is TRUE, if user confirms to overwrite file.
  595. */
  596.  
  597. BOOL Do_OverwriteRequest(struct Window *Win, char *PubScreenName, WORD Left, WORD Top)
  598. {
  599. BOOL rc = FALSE;
  600. LONG result = RESULT_NOTHING;
  601. ULONG waitsigs, mask;
  602.  
  603. if (OpenOverwriteReqWindow(PubScreenName) == TRUE) {
  604.     waitsigs = overwr_rwd->RWD_WSignals|SIGBREAKF_CTRL_C;
  605.  
  606.     while(result == RESULT_NOTHING) {
  607.         mask = Wait(waitsigs);
  608.         if (mask & overwr_rwd->RWD_WSignals) {
  609.             result = HandleOverwriteReqWindow();
  610.             }
  611.         if (mask & SIGBREAKF_CTRL_C) {
  612.             result = RESULT_CANCEL;
  613.             }
  614.         if (result == RESULT_OK) rc = TRUE;
  615.         }
  616.  
  617.     CloseOverwriteReqWindow();
  618.     }
  619.  
  620. LoadRGB32(ViewPortAddress (Win), (APTR) PALETTE);
  621. return(rc);
  622. }
  623.  
  624. /*    OpenOverwriteReqWindow(): open window of overwrite-requester.
  625.  
  626.         SYNOPSIS: BOOL res = OpenOverwriteReqWindow
  627.                         (
  628.                         char                  *PubScreenName;
  629.                         );
  630.  
  631.         INPUTS:        -
  632.  
  633.         RETURNS:        res:
  634.                             TRUE, if successfull.
  635. */
  636.  
  637. BOOL OpenOverwriteReqWindow(char *PubScreenName)
  638. {
  639. if (overwr_rwd = OpenReactionWindow(WIN_OVERWRITE_ID, GROUP_Overwrite_ID, PubScreenName)) return(TRUE);
  640. return(FALSE);
  641. }
  642.  
  643. /*    CloseOverwriteReqWindow(): close window of overwrite-requester.
  644.  
  645.         SYNOPSIS: void = CloseOverwriteReqWindow
  646.                         (
  647.                         void
  648.                         );
  649.  
  650.         INPUTS:        -
  651.  
  652.         RETURNS:        -
  653. */
  654.  
  655. void CloseOverwriteReqWindow(void)
  656. {
  657. CloseReactionWindow(overwr_rwd);
  658. }
  659.  
  660. /*    HandleOverwriteReqWindow(): Handle the messages of the overwrite-requester.
  661.  
  662.         SYNOPSIS: LONG res = HandleOverwriteReqWindow
  663.                         (
  664.                         void;
  665.                         );
  666.  
  667.         INPUTS:        -
  668.  
  669.         RETURNS:        res:
  670.                             result of messages:    RESULT_NOTHING -> nothing happens.
  671.                                                         RESULT_CANCEL  -> user canceled.
  672.                                                         RESULT_OK      -> user wants to overwrite.
  673. */
  674.  
  675. LONG HandleOverwriteReqWindow(void)
  676. {
  677. LONG rc = RESULT_NOTHING;
  678. ULONG result, code;
  679.  
  680. while((result = DoMethod(overwr_rwd->RWD_WindowObject, WM_HANDLEINPUT, &code)) != WMHI_LASTMSG) {
  681.  
  682.     switch (result & WMHI_CLASSMASK) {
  683.         case WMHI_CLOSEWINDOW:
  684.             rc = RESULT_CANCEL;
  685.             break;
  686.  
  687.         case WMHI_GADGETUP:
  688.             switch (result & RL_GADGETMASK) {
  689.                 case OverWr_BUTTON_Yes:
  690.                     rc = RESULT_OK;
  691.                     break;
  692.                 case OverWr_BUTTON_No:
  693.                     rc = RESULT_CANCEL;
  694.                     break;
  695.                 }
  696.             break;
  697.         }
  698.     }
  699. return(rc);
  700. }
  701.